home *** CD-ROM | disk | FTP | other *** search
/ Multimedia Madness 2 #12 / Multimedia Madness - Volume 2 - Issue 12 (SAMS Publishing) (November 25, 1992).iso / nemo / stringpp / str.h < prev    next >
C/C++ Source or Header  |  1992-10-08  |  10KB  |  266 lines
  1. /* -------------------------------------------------------------------- */
  2. /* String++ Version 2.10            str.h         Last revised 10/08/92 */
  3. /*                                                                      */
  4. /* Enhanced string class for Turbo C++/Borland C++.                     */
  5. /* Copyright 1991, 1992 by Carl W. Moreland                             */
  6. /* -------------------------------------------------------------------- */
  7.  
  8. #ifndef STRdotH
  9. #define STRdotH
  10.  
  11. #include <string.h>
  12. #include <iostream.h>
  13.  
  14. #define LEFT_JUSTIFY    0        // obsolete - use LEFT
  15. #define CENTER_JUSTIFY    1        // obsolete - use CENTER
  16. #define RIGHT_JUSTIFY    2        // obsolete - use RIGHT
  17. #define LEFT        0
  18. #define CENTER          1
  19. #define RIGHT            2
  20. #define NOCLIP        0
  21. #define CLIP        1
  22. #define WHITESPACE    0
  23.  
  24. class string
  25. {
  26. private:
  27.   char *_ptr;
  28.  
  29. public:
  30.   string();                // default constructor;
  31.   string(const char c,            // initialize with a character,
  32.          unsigned n = 1);        //   optional # of characters
  33.   string(const char *s,            // initialize with a char *,
  34.          unsigned pos = 0,        //   optional starting char
  35.          unsigned len = 10000);        //   optional # of chars
  36.   string(const string& s,        // initialize with another string,
  37.          unsigned pos = 0,        //   optional starting char
  38.          unsigned len = 10000);        //   optional # of chars
  39.   string(int n)  { string((long)n); }    // initialize with an integer
  40.   string(long n);            // initialize with a long int
  41.  
  42.  ~string(void);
  43.  
  44.   char* ptr(void) const                      { return _ptr; }
  45.   const char* operator()() const             { return _ptr; }
  46.   const char* operator()(unsigned pos) const { return _ptr + pos; }
  47.   string      operator()(unsigned pos, unsigned len) const;
  48.  
  49.   int     Length(void) const { return strlen(_ptr); }
  50.   int     Len(void)    const { return strlen(_ptr); }
  51.   string& toUpper(void);        // convert str to uppercase
  52.   string& toLower(void);        // convert str to lowercase
  53.   int&    Value(int& n);        // convert str to an integer
  54.   long&   Value(long& n);        // convert str to a long int
  55.  
  56.   string& Left(unsigned len);        // left   len chars
  57.   string& Right(unsigned len);        // right  len chars
  58.   string& Mid(unsigned pos,        // middle len chars from pos
  59.               unsigned len);
  60.   string& Justify(int mode,        // justify str according to mode
  61.                   unsigned len,
  62.           int clip=0);
  63.   string& Trim(int mode = CENTER,    // Delete leading/trailing whitespace
  64.                char ch = WHITESPACE);
  65.  
  66.   string& Insert(unsigned pos,        // insert substring
  67.                  const string& s);
  68.   string& Delete(unsigned pos,        // delete substring
  69.                  unsigned len = 10000);
  70.   char*   Copy(char *);            // copy str to char* (non-const)
  71.  
  72.   int     Index(const string& t);    // position of t in str
  73.   string  SubStr(unsigned p,        // substring of str at position p
  74.                  unsigned n=10000);
  75.   int     Split(string **a,        // split str into an array a on
  76.                 const string& fs);    //   field separator fs
  77.   int     Sub(const string& from,    // substitute from with to in str
  78.               const string& to,
  79.           unsigned count=10000);
  80.  
  81.   string& operator=(const char);    // str1 = char
  82.   string& operator=(const char*);    // str1 = char*
  83.   string& operator=(const string&);    // str1 = str
  84.   string& operator=(const int);        // str1 = n
  85.   string& operator=(const long);    // str1 = n
  86.   string& operator=(const float);    // str1 = x
  87.   string& operator=(const double);    // str1 = x
  88.   string& operator+=(const char);    // str1 += char
  89.   string& operator+=(const char*);    // str1 += char*
  90.   string& operator+=(const string&);    // str1 += str
  91.   string& operator*=(unsigned n);    // str1 *= n
  92.   char&   operator[](unsigned i) const;    // ch = str[i] or str[i] = ch
  93.  
  94.   friend string operator +  (const string&, const string&);
  95.   friend string operator +  (const string&, const char*);
  96.   friend string operator +  (const char*,   const string&);
  97.   friend string operator *  (const string&, int n);
  98.   friend int    operator == (const string&, const string&);
  99.   friend int    operator == (const string&, const char*);
  100.   friend int    operator == (const char*,   const string&);
  101.   friend int    operator != (const string&, const string&);
  102.   friend int    operator != (const string&, const char*);
  103.   friend int    operator != (const char*,   const string&);
  104.   friend int    operator <  (const string&, const string&);
  105.   friend int    operator <  (const string&, const char*);
  106.   friend int    operator <  (const char*,   const string&);
  107.   friend int    operator >  (const string&, const string&);
  108.   friend int    operator >  (const string&, const char*);
  109.   friend int    operator >  (const char*,   const string&);
  110.   friend int    operator <= (const string&, const string&);
  111.   friend int    operator <= (const string&, const char*);
  112.   friend int    operator <= (const char*,   const string&);
  113.   friend int    operator >= (const string&, const string&);
  114.   friend int    operator >= (const string&, const char*);
  115.   friend int    operator >= (const char*,   const string&);
  116.  
  117.   /* --- Awk-style functions ------------------------------------------ */
  118.  
  119.   friend int    length(const string& s) { return s.Len(); }
  120.   friend int    index(const string& s, const string& t);
  121.   friend string substr(const string& s, unsigned p, unsigned n=10000);
  122.   friend int    split(const string& s, string **a, const string& fs);
  123.   friend int    gsub(const string& from, const string& to, string& str, unsigned count=10000);
  124.   friend int    sub(const string& from, const string& to, string& str);
  125.   friend int    match(const string& s, const string& r);
  126.  
  127.   /* --- Other C-style functions -------------------------------------- */
  128.  
  129.   friend string toupper(const string& s);
  130.   friend string tolower(const string& s);
  131.   friend string left(const string& s, unsigned n);
  132.   friend string right(const string& s, unsigned n);
  133.   friend string mid(const string& s, unsigned p, unsigned n);
  134.   friend string justify(const string& s, int mode, unsigned len, int clip=1);
  135.   friend string trim(const string& s, int mode=CENTER);
  136.  
  137.   /* --- Obsolete naming conventions ---------------------------------- */
  138.  
  139.   int     length(void) const { return strlen(_ptr); }
  140.   int     len(void)    const { return strlen(_ptr); }
  141.  
  142.   string  left(unsigned len) const { string tmp; return tmp.Left(len); }
  143.   string  right(unsigned len) const { string tmp; return tmp.Right(len); }
  144.   string  mid(unsigned pos, unsigned len) const { string tmp; return tmp.Mid(pos, len); }
  145.   string  justify(int mode, unsigned len, int clip=0) const { string tmp; return tmp.Justify(mode, len, clip); }
  146.  
  147.   string& toupper(void) { return toUpper(); }
  148.   string& tolower(void) { return toLower(); }
  149. };
  150.  
  151. class String: public string
  152. {
  153. public:
  154.   String():
  155.     string() {}
  156.   String(const char c, unsigned n = 1):
  157.     string(c, n) {}
  158.   String(const char *s, unsigned pos = 0, unsigned len = 10000):
  159.     string(s, pos, len) {}
  160.   String(const string& s, unsigned pos = 0, unsigned len = 10000):
  161.     string(s, pos, len) {}
  162.   String(int n):
  163.     string((long)n) {}
  164.   String(long n):
  165.     string(n) {}
  166. };
  167.  
  168. ostream& operator<<(ostream&, const string&);
  169. istream& operator>>(istream&, string&);
  170.  
  171. inline int operator==(const string& s1, const char* s2) {
  172.   return strcmp(s1._ptr,s2)==0;
  173. }
  174.  
  175. inline int operator==(const char* s1, const string& s2) {
  176.   return strcmp(s1,s2._ptr)==0;
  177. }
  178.  
  179. inline int operator==(const string& s1, const string& s2) {
  180.   return strcmp(s1._ptr,s2._ptr)==0;
  181. }
  182.  
  183. inline int operator!=(const string& s1, const char *s2) {
  184.   return strcmp(s1._ptr,s2)!=0;
  185. }
  186.  
  187. inline int operator!=(const char *s1, const string& s2) {
  188.   return strcmp(s1,s2._ptr)!=0;
  189. }
  190.  
  191. inline int operator!=(const string& s1, const string& s2) {
  192.   return strcmp(s1._ptr,s2._ptr)!=0;
  193. }
  194.  
  195. inline int operator<(const string& s1, const char *s2) {
  196.   return strcmp(s1._ptr,s2)< 0;
  197. }
  198.  
  199. inline int operator<(const char *s1, const string& s2) {
  200.   return strcmp(s1,s2._ptr)< 0;
  201. }
  202.  
  203. inline int operator<(const string& s1, const string& s2) {
  204.   return strcmp(s1._ptr,s2._ptr)< 0;
  205. }
  206.  
  207. inline int operator>(const string& s1, const char *s2) {
  208.   return strcmp(s1._ptr,s2)> 0;
  209. }
  210.  
  211. inline int operator>(const char *s1, const string& s2) {
  212.   return strcmp(s1,s2._ptr)> 0;
  213. }
  214.  
  215. inline int operator>(const string& s1, const string& s2) {
  216.   return strcmp(s1._ptr,s2._ptr)> 0;
  217. }
  218.  
  219. inline int operator<=(const string& s1, const char *s2) {
  220.   return strcmp(s1._ptr,s2)<=0;
  221. }
  222.  
  223. inline int operator<=(const char *s1, const string& s2) {
  224.   return strcmp(s1,s2._ptr)<=0;
  225. }
  226.  
  227. inline int operator<=(const string& s1, const string& s2) {
  228.   return strcmp(s1._ptr,s2._ptr)<=0;
  229. }
  230.  
  231. inline int operator>=(const string& s1, const char *s2) {
  232.   return strcmp(s1._ptr,s2)>=0;
  233. }
  234.  
  235. inline int operator>=(const char *s1, const string& s2) {
  236.   return strcmp(s1,s2._ptr)>=0;
  237. }
  238.  
  239. inline int operator>=(const string& s1, const string& s2) {
  240.   return strcmp(s1._ptr,s2._ptr)>=0;
  241. }
  242.  
  243. // Obsolete methods
  244.  
  245. inline int string::Index(const string& t) {
  246.   return index(*this, t);
  247. }
  248.  
  249. inline string string::SubStr(unsigned p, unsigned n) {
  250.   return substr(*this, p, n);
  251. }
  252.  
  253. inline int string::Split(string **a, const string& fs) {
  254.   return split(*this, a, fs);
  255. }
  256.  
  257. inline int string::Sub(const string& from, const string& to, unsigned count) {
  258.   return gsub(from, to, *this, count);
  259. }
  260.  
  261. inline int sub(const string& from, const string& to, string& str) {
  262.   return gsub(from, to, str, 1);
  263. }
  264.  
  265. #endif
  266.